<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<!--[if lt IE 9]>
  <script src="https://oss.maxcdn.com/libs/html5shiv/3.7.0/html5shiv.js"></script>
<![endif]-->
<title>VIM 中文帮助: C 及其它语言的自动缩进</title>
<link rel="stylesheet" href="vim-stylesheet.css" type="text/css" />
<link rel="canonical" href="https://yianwillis.github.io/vimcdoc/doc/indent.html" />
<script type="text/javascript" src="vimcdoc.js"></script>
<meta name="viewport" content="width=device-width, initial-scale=1" />
</head>
<body>
<nav id=banner>
<form action=tags.html target="tag_iframe">
  <input type="text" name="tag" id="tag" placeholder="标签搜索">
</form>
<iframe name="tag_iframe" src=""></iframe>
<a href="help.html">帮助总览</a> &middot;
<hr/>
<a href="quickref.html">快速参考</a> &middot;
<a href="index.html">命令索引</a> &middot;
<a href="eval.html#functions">函数列表</a> &middot;
<a href="quickref.html#option-list">选项列表</a> &middot;
<hr/>
<a href="usr_toc.html">用户手册</a> &middot;
<a href="help.html#reference_toc">参考手册</a> &middot;
</nav>

<header>
<h2>indent</h2>
</header>
<article id=outer>
<section class=inner>
<b class="vimtag"> <a name="indent.txt">indent.txt</a> </b>    适用于 Vim 9.0 版本。   最近更新: 2023年2月


                  <code class="vim">VIM 参考手册    by Bram Moolenaar</code>
                                <code class="vim">译者</code>: wandys


本文讨论 C 程序以及其它文件类型的缩进。

1. 缩进 C 风格的程序             <a href="indent.html#C-indenting">C-indenting</a> 
2. 按表达式缩进                  <a href="indent.html#indent-expression">indent-expression</a> 

</section><hr class="doubleline" /><section class=inner>
<h4>1. 缩进 C 风格的程序                                    <b class="vimtag"> <a name="C-indenting">C-indenting</a> </b></h4>
有关 C 风格的缩进的基本操作请参用户手册的  <a href="usr_30.html#30.2">30.2</a> 。

Vim 有很多自动缩进 C 风格程序的选项。不少编程语言，如 Java 和 C++，都和 C 的排
版习惯非常相近。这些选项只对缩进有影响而不处理其他形式的排版。另有一些选项影响
其它类型的排版和缩进，大体可参阅  <a href="change.html#format-comments">format-comments</a> 、 <a href="change.html#fo-table">fo-table</a> 、 <a href="change.html#gq">gq</a>  和
 <a href="change.html#formatting">formatting</a> 。

实际上主要有四种可用缩进的方式，如果同时指定或对 <a href="options.html#'indentexpr'">'indentexpr'</a> 而言非空，列于后
者优先于列于前者:
<a href="options.html#'autoindent'">'autoindent'</a>    沿用上一行的缩进。
<a href="options.html#'smartindent'">'smartindent'</a>   类似 <a href="options.html#'autoindent'">'autoindent'</a>，但是可以识别一些 C 语法以能在合适的地方
                增加 / 减少缩进。
<a href="options.html#'cindent'">'cindent'</a>       比上面两个更聪明；可以设置不同的缩进风格。
<a href="options.html#'indentexpr'">'indentexpr'</a>    最灵活的一个: 根据表达式来计算缩进。若此选项非空，则优先于其它
                选项覆盖。参见  <a href="indent.html#indent-expression">indent-expression</a> 。
本节下面的内容介绍 <a href="options.html#'cindent'">'cindent'</a> 选项。

<code class="note">注意</code> <a href="options.html#'cindent'">'cindent'</a> 缩进不一定对所有的代码都起作用。Vim 不是 C 编译器: 它不能识别出
所有的语法。一个要求是顶层函数必须在第一列中含有 '{'。否则它们容易与声明混淆。

这五个选项控制 C 程序缩进:
<a href="options.html#'cindent'">'cindent'</a>       使 Vim 对 C 程序自动缩进。
<a href="options.html#'cinkeys'">'cinkeys'</a>       指定在插入模式下按哪个键可以再次缩进。
<a href="options.html#'cinoptions'">'cinoptions'</a>    设定你喜好的缩进模式。
<a href="options.html#'cinwords'">'cinwords'</a>      定义在下一行中开始一个额外缩进的关键字。
<a href="options.html#'cinscopedecls'">'cinscopedecls'</a> 定义识别为 C++ 作用域声明的字符串。

如果 <a href="options.html#'lisp'">'lisp'</a> 选项没被打开并且 <a href="options.html#'equalprg'">'equalprg'</a> 为空，"=" 操作符将使用 Vim 的内建算法
而不调用外部程序。

若要对 C 文件自动设定 <a href="options.html#'cindent'">'cindent'</a> 选项而在其它文件里复位，请参考  <a href="autocmd.html#autocommand">autocommand</a> 。

                                        <b class="vimtag"> <a name="cinkeys-format">cinkeys-format</a> </b> <b class="vimtag"> <a name="indentkeys-format">indentkeys-format</a> </b>
<a href="options.html#'cinkeys'">'cinkeys'</a> 选项是这样的一个字符串: 控制 Vim 在输入特定字符或是在特定上下文下的
命令后引起的缩进。<code class="note">备注</code> 这不仅仅触发 C-缩进。 若 <a href="options.html#'indentexpr'">'indentexpr'</a> 非空，将会使用
<a href="options.html#'indentkeys'">'indentkeys'</a> 而不是 <a href="options.html#'cinkeys'">'cinkeys'</a>。<a href="options.html#'cinkeys'">'cinkeys'</a> 和 <a href="options.html#'indentkeys'">'indentkeys'</a> 的格式是一样的。

其缺省值是 "0<code class="special">{,0}</code>,0),0],:,0#,!^F,o,O,e"。解释如下:

        "0{"    如果在该行输入的第一个字符是 '{'
        "0}"    如果在该行输入的第一个字符是 '}'
        "0)"    如果在该行输入的第一个字符是 ')'
        "0]"    如果在该行输入的第一个字符是 ']'
        ":"     如果在标号或是 case 语句后输入 ':'
        "0#"    如果在该行输入的第一个字符是 '#'
        "!^F"   如果输入 <code class="keystroke">CTRL-F</code> (它不会被插入)
        "o"     如果输入 <code class="special">&lt;CR&gt;</code> 或是使用 "o" 命令
        "O"     如果使用 "O" 命令
        "e"     如果输入处于行首的 "else" 的第二个 'e'

可以加在键值前面的字符:                                         <b class="vimtag"> <a name="i_CTRL-F">i_CTRL-F</a> </b>
!       当 '!' 在一个键值前面，Vim 将不会插入那个键而是将当前行再次缩进。这可
        以用来定义一个再次缩进当前行的键。<code class="keystroke">CTRL-F</code> 是缺省的键。将 <code class="keystroke">CTRL-I</code> 设定为
        这个键时要小心，因为 <code class="keystroke">CTRL-I</code> 用来表示 <code class="special">&lt;Tab&gt;</code> 的 ASCII 码。

*       当 '*' 在一个键值前面，会在插入此键之前再次缩进当前行。如果 <a href="options.html#'cinkeys'">'cinkeys'</a>
        包含 "*<code class="special">&lt;Return&gt;</code>"，Vim 在开启一个新行之前再次缩进当前行。
0       当 '0' 在一个键值前面 (但可以在 '!' 或 '*' 后面)，只有当此键是该行你输
        入的第一个字符时，Vim 才再次缩进当前行。如果在 "=" 之前使用，只有当此
        单词前面全是空白字符时 Vim 才再次缩进当前行。

如果 '!' 和 '*' 都不在键值前，Vim 将在你输入那个键后再次缩进当前行。 因此 ';'
触发一个包含 ';' 本身在内的行的缩进。

特殊键:
<code class="special">&lt;&gt;</code>      尖括号表示一个键名本身。例如: "<code class="special">&lt;Up&gt;</code>"，"<code class="special">&lt;Ins&gt;</code>" (参见  <a href="intro.html#key-notation">key-notation</a> )。
^       以 '^' 开头的字符串表示一个控制字符。比如，"^F" 是 <code class="keystroke">CTRL-F</code>。
o       当使用 "o" 命令或是在当前行后开启一个新行时 (例如，在插入模式输入
        <code class="special">&lt;Enter&gt;</code> 时) 再次缩进当前行。
O       当使用 "O" 命令时再次缩进当前行。
e       当输入第二个 'e' 时，再次缩进由 "else" 开头的行。
:       在一个标号或是 case 语句后输入 ':' 时，再次缩进当前行；不对 C++ 中的
        "class::method" 这种形式缩进。若要对所有的 ":" 都缩进，使用 "&lt;:&gt;"。
=word   当输入 "word" 的最后一个字母时再次缩进。"word" 可以是一个单词的一部
        分。比如当输入 "endif" 或是 "endwhile" 中的 "d" 时，"=end" 都能引起再
        次缩进。但当输入 "bend" 时就没有反应。另外，当补全功能产生了一个以
        "word" 开头的单词时也会再次缩进。"0=word" 是当单词前有空白符时才缩进。
=~word  类似 "=word"，但忽略大小写。

如果你想在输入 'o'、'O'、'e'、'0'、'&lt;'、'&gt;'、'*'、':'、'!' 时产生再次缩进，请
分别使用 "<code class="special">&lt;o&gt;</code>"、"<code class="special">&lt;O&gt;</code>"、"<code class="special">&lt;e&gt;</code>"、"<code class="special">&lt;0&gt;</code>"、"&lt;<code class="special">&lt;&gt;</code>"、"<code class="special">&lt;&gt;</code>&gt;"、"&lt;*&gt;"、"&lt;:&gt;"、"&lt;!&gt;"。

emacs 风格的缩进模式并不是每次输入 <code class="special">&lt;Enter&gt;</code> 都缩进，而是只在输入 <code class="special">&lt;Tab&gt;</code> 时才缩
进。对此，我建议使用: 
<code class="example">        :set cinkeys=0{,0},:,0#,!&lt;Tab&gt;,!^F</code>
你也许还需要关掉 <a href="options.html#'autoindent'">'autoindent'</a> 选项。

<code class="note">备注</code>: 如果你手动地改变了当前行的缩进，Vim 会忽略对此行的 cindent (<code class="vim">译者注</code>: 也包
含 <a href="options.html#'indentexpr'">'indentexpr'</a>) 设定。因此如果你输入 <code class="special">&lt;BS&gt;</code>、<code class="special">&lt;Tab&gt;</code>、<code class="special">&lt;Space&gt;</code>、<code class="keystroke">CTRL-T</code>、或是
<code class="keystroke">CTRL-D</code> 来改变缩进，Vim 将不会再次缩进。

                                                <b class="vimtag"> <a name="cinoptions-values">cinoptions-values</a> </b>
<a href="options.html#'cinoptions'">'cinoptions'</a> 选项决定 Vim 来如何进行缩进。选项之后的值采用以下形式之一 (N 为
任何数字):
        N       缩进 N 个空格
        -N      向左缩进 N 个空格
        Ns      N 倍 <a href="options.html#'shiftwidth'">'shiftwidth'</a> 个空格
        -Ns     向左 N 倍 <a href="options.html#'shiftwidth'">'shiftwidth'</a> 个空格

在下面的列表中，"N" 表示一个你选择的数字 (可以为负数)。如果数字后有一个 's'，
Vim 将那个数字乘以 <a href="options.html#'shiftwidth'">'shiftwidth'</a>: "1s" 是 <a href="options.html#'shiftwidth'">'shiftwidth'</a>，"2s" 是 <a href="options.html#'shiftwidth'">'shiftwidth'</a> 的
两倍，以此类推。你也可以使用小数点: "-0.5s" 是 <a href="options.html#'shiftwidth'">'shiftwidth'</a> 一半的负值。
下面的例子假定 <a href="options.html#'shiftwidth'">'shiftwidth'</a> 为 4。
                                                        <b class="vimtag"> <a name="cino-%3E">cino-&gt;</a> </b>
        &gt;N    "一般" 缩进的增加值。在需要增加缩进的行 (比如，以 "if" 或是 "{"
              等开头的行) 之后使用。(缺省为 <a href="options.html#'shiftwidth'">'shiftwidth'</a>)。

                cino=               cino=&gt;2             cino=&gt;2s 
<code class="example">                  if (cond)           if (cond)           if (cond)</code>
<code class="example">                  {                   {                   {</code>
<code class="example">                      foo;              foo;                      foo;</code>
<code class="example">                  }                   }                   }</code>

                                                        <b class="vimtag"> <a name="cino-e">cino-e</a> </b>
        eN    当 '{' 在行尾 (End，更准确地，不在行首) 时，相对 '一般' 缩进增加
              N 个字符的缩进。如果你想对 '{' 在行首时和 '{' 在行尾时使用不同的
              缩进，这将很有用。(缺省为 0)。

                cino=               cino=e2             cino=e-2 
<code class="example">                  if (cond) {         if (cond) {         if (cond) {</code>
<code class="example">                      foo;                  foo;            foo;</code>
<code class="example">                  }                   }                   }</code>
<code class="example">                  else                else                else</code>
<code class="example">                  {                   {                   {</code>
<code class="example">                      bar;                bar;                bar;</code>
<code class="example">                  }                   }                   }</code>

                                                        <b class="vimtag"> <a name="cino-n">cino-n</a> </b>
        nN    如果一个在 "if"，"while" 等等后面的语句不在 (Not) 大括号内，则相
              对 '一般' 缩进增加 N 个字符的缩进。如果你要对语句前有 '{' 和没有
              '{' 使用不同的缩进，这将很有用。(缺省为 0)。

                cino=               cino=n2             cino=n-2 
<code class="example">                  if (cond)           if (cond)           if (cond)</code>
<code class="example">                      foo;                  foo;            foo;</code>
<code class="example">                  else                else                else</code>
<code class="example">                  {                   {                   {</code>
<code class="example">                      bar;                bar;                bar;</code>
<code class="example">                  }                   }                   }</code>

                                                        <b class="vimtag"> <a name="cino-f">cino-f</a> </b>
        fN    将函数或是其他代码块开头的 '{' 放在第 N 列。这只对不包含于其他大
              括号内并且处于行首的 '{' 起作用。'{' 之后的代码对它的相对位置不
              变。(缺省为 0)。

                cino=               cino=f.5s           cino=f1s 
<code class="example">                  func()              func()              func()</code>
<code class="example">                  {                     {                     {</code>
<code class="example">                      int foo;              int foo;              int foo;</code>

                                                        <b class="vimtag"> <a name="cino-{">cino-{</a> </b>
        {N    将 '{' 置于 '一般' 缩进后 N 个字符的位置。这只对包括在其他大括号
              内的 '{' 起作用。(缺省为 0)。

                cino=               cino={.5s           cino={1s 
<code class="example">                  if (cond)           if (cond)           if (cond)</code>
<code class="example">                  {                     {                     {</code>
<code class="example">                      foo;                foo;                foo;</code>

                                                        <b class="vimtag"> <a name="cino-}">cino-}</a> </b>
        }N    将 '}' 放在与之匹配的 '{' 之后 N 个字符处。(缺省为 0)。

                cino=               cino=<code class="special">{2,}</code>-0.5s      cino=}2 
<code class="example">                  if (cond)           if (cond)           if (cond)</code>
<code class="example">                  {                     {                 {</code>
<code class="example">                      foo;                foo;                foo;</code>
<code class="example">                  }                   }                     }</code>

                                                        <b class="vimtag"> <a name="cino-^">cino-^</a> </b>
        ^N    如果 '{' 在第 0 列，则对其包含的语句增加相对 '一般' 縮进 N 个字
              符的缩进。这可以对整个函数设定一个不同的缩进。(有人喜欢将其设成
              负数)。(缺省为 0)。

                cino=               cino=^-2            cino=^-s 
<code class="example">                  func()              func()              func()</code>
<code class="example">                  {                   {                   {</code>
<code class="example">                      if (cond)         if (cond)         if (cond)</code>
<code class="example">                      {                 {                 {</code>
<code class="example">                          a = b;            a = b;            a = b;</code>
<code class="example">                      }                 }                 }</code>
<code class="example">                  }                   }                   }</code>

                                                        <b class="vimtag"> <a name="cino-L">cino-L</a> </b>
        LN    控制跳转标签的放置。如果 N 为负，标签放在第一列上。如果 N 非负，
              标签的缩进位置为 '一般' 缩进位置减去 N。(缺省为 -1)。

                cino=               cino=L2             cino=Ls 
<code class="example">                  func()              func()              func()</code>
<code class="example">                  {                   {                   {</code>
<code class="example">                      {                   {                   {</code>
<code class="example">                          stmt;               stmt;               stmt;</code>
<code class="example">                  LABEL:                    LABEL:            LABEL:</code>
<code class="example">                      }                   }                   }</code>
<code class="example">                  }                   }                   }</code>

                                                        <b class="vimtag"> <a name="cino-:">cino-:</a> </b>
        :N    将 case 标号放在 switch() 缩进位置之后的 N 个字符处。(缺省为
              <a href="options.html#'shiftwidth'">'shiftwidth'</a>)。

                cino=               cino=:0 
<code class="example">                  switch (x)          switch(x)</code>
<code class="example">                  {                   {</code>
<code class="example">                      case 1:         case 1:</code>
<code class="example">                          a = b;          a = b;</code>
<code class="example">                      default:        default:</code>
<code class="example">                  }                   }</code>

                                                        <b class="vimtag"> <a name="cino-%20">cino-=</a> </b>
        =N    将 case 标号之后的语句放在标号缩进位置之后的 N 个字符处。(缺省为
              <a href="options.html#'shiftwidth'">'shiftwidth'</a>)。

                cino=               cino==10 
<code class="example">                   case 11:             case 11:  a = a + 1;</code>
<code class="example">                       a = a + 1;                 b = b + 1;</code>

                                                        <b class="vimtag"> <a name="cino-l">cino-l</a> </b>
        lN    如果 N 不为 0，Vim 将会和 case 标号对齐，而不是和同一行其后的语
              句对齐。

                cino=                       cino=l1 
<code class="example">                    switch (a) {              switch (a) {</code>
<code class="example">                        case 1: {                 case 1: {</code>
<code class="example">                                    break;            break;</code>
<code class="example">                                }                 }</code>

                                                        <b class="vimtag"> <a name="cino-b">cino-b</a> </b>
        bN    如果 N 不为 0，Vim 会将最后的 "break" 和 case 标号对齐，这样
              case..break 看起来有点像一个代码块。(缺省为 0)。
              使用 1 时，考虑在 <a href="options.html#'cinkeys'">'cinkeys'</a> 中加入 "0=break"。

                cino=               cino=b1 
<code class="example">                  switch (x)          switch(x)</code>
<code class="example">                  {                   {</code>
<code class="example">                      case 1:             case 1:</code>
<code class="example">                          a = b;              a = b;</code>
<code class="example">                          break;          break;</code>
<code class="example"></code>
<code class="example">                      default:            default:</code>
<code class="example">                          a = 0;              a = 0;</code>
<code class="example">                          break;          break;</code>
<code class="example">                  }                   }</code>

                                                        <b class="vimtag"> <a name="cino-g">cino-g</a> </b>
        gN    将 C++ 作用域声明置于其所在代码块的 N 个字符后。(缺省为
              <a href="options.html#'shiftwidth'">'shiftwidth'</a>)。缺省，作用域声明可以是 "public:"、"protected:" 或
              者 "private:"。此列表可用 <a href="options.html#'cinscopedecls'">'cinscopedecls'</a> 选项修改。

                cino=               cino=g0 
<code class="example">                  {                   {</code>
<code class="example">                      public:         public:</code>
<code class="example">                          a = b;          a = b;</code>
<code class="example">                      private:        private:</code>
<code class="example">                  }                   }</code>

                                                        <b class="vimtag"> <a name="cino-h">cino-h</a> </b>
        hN    将 C++ 作用域声明后面的语句置于对应标号的 N 个字符后。(缺省为
              <a href="options.html#'shiftwidth'">'shiftwidth'</a>)。

                cino=               cino=h10 
<code class="example">                   public:              public:   a = a + 1;</code>
<code class="example">                       a = a + 1;                 b = b + 1;</code>

                                                        <b class="vimtag"> <a name="cino-N">cino-N</a> </b>
        NN     C++ namespace 之内的相对普通块的额外缩进 N 个字符。(缺省为 0)。

                cino=                      cino=N-s 
<code class="example">                  namespace {                namespace {</code>
<code class="example">                      void function();       void function();</code>
<code class="example">                  }                          }</code>
<code class="example"></code>
<code class="example">                  namespace my               namespace my</code>
<code class="example">                  {                          {</code>
<code class="example">                      void function();       void function();</code>
<code class="example">                  }                          }</code>

                                                        <b class="vimtag"> <a name="cino-E">cino-E</a> </b>
        EN    C++  链接性声明 (extern "C" 或 externa "C++") 之内的相对普通块的
              额外缩进 N 个字符。(缺省为 0)。

                cino=                      cino=E-s 
<code class="example">                  extern "C" {               extern "C" {</code>
<code class="example">                      void function();       void function();</code>
<code class="example">                  }                          }</code>
<code class="example"></code>
<code class="example">                  extern "C"                 extern "C"</code>
<code class="example">                  {                          {</code>
<code class="example">                      void function();       void function();</code>
<code class="example">                  }                          }</code>

                                                        <b class="vimtag"> <a name="cino-p">cino-p</a> </b>
        pN    在 K&amp;R 形式的函数声明中，将参数的声明放在 N 个字符的相对位置。
              (缺省为 <a href="options.html#'shiftwidth'">'shiftwidth'</a>)。

                cino=               cino=p0             cino=p2s 
<code class="example">                  func(a, b)          func(a, b)          func(a, b)</code>
<code class="example">                      int a;          int a;                      int a;</code>
<code class="example">                      char b;         char b;                     char b;</code>

                                                        <b class="vimtag"> <a name="cino-t">cino-t</a> </b>
        tN    将函数返回值类型声明放在 N 个字符的相对位置。(缺省为
              <a href="options.html#'shiftwidth'">'shiftwidth'</a>)。

                cino=               cino=t0             cino=t7 
<code class="example">                      int             int                        int</code>
<code class="example">                  func()              func()              func()</code>

                                                        <b class="vimtag"> <a name="cino-i">cino-i</a> </b>
        iN    缩进 C++ 的基类声明和构造函数初始化部分，如果它们处于行首 (否
              则，它们对齐在 ':' 的右侧)。(缺省为 <a href="options.html#'shiftwidth'">'shiftwidth'</a>)。

                cino=                     cino=i0 
<code class="example">                  class MyClass :           class MyClass :</code>
<code class="example">                      public BaseClass      public BaseClass</code>
<code class="example">                  {}                        {}</code>
<code class="example">                  MyClass::MyClass() :      MyClass::MyClass() :</code>
<code class="example">                      BaseClass(3)          BaseClass(3)</code>
<code class="example">                  {}                        {}</code>

                                                        <b class="vimtag"> <a name="cino-+">cino-+</a> </b>
        +N    函数之内的续行 (在下一行继续的行) 缩进增加额外的 N 个字符。(缺省
              为 <a href="options.html#'shiftwidth'">'shiftwidth'</a>)。
              函数之外，如果前行以反斜杠结尾，使用 2 * N。

                cino=                     cino=+10 
<code class="example">                  a = b + 9 *               a = b + 9 *</code>
<code class="example">                      c;                              c;</code>

                                                        <b class="vimtag"> <a name="cino-c">cino-c</a> </b>
        cN    如果没有其它文本可供对齐的话，注释头部 (<code class="vim">译者注</code>: /*) 之后的注释行
              相对注释头部 N 个字符的缩进。(缺省为 3)。
              参见  <a href="change.html#format-comments">format-comments</a> 。

                cino=                     cino=c5 
<code class="example">                  /*                        /*</code>
<code class="example">                     text.                       text.</code>
<code class="example">                   */                        */</code>

                                                        <b class="vimtag"> <a name="cino-C">cino-C</a> </b>
        CN    如果 N 非零，像上面 c 选项一样对注释缩进，即使 /* 后面还有其他文
              字也是如此。

                cino=c0                   cino=c0,C1 
<code class="example">                  /********                 /********</code>
<code class="example">                    text.                   text.</code>
<code class="example">                  ********/                 ********/</code>
              (示例使用了 ":set comments&amp; comments-=s1:/* comments^=s0:/*")

                                                        <b class="vimtag"> <a name="cino-%2F">cino-/</a> </b>
        /N    将注释行增加额外的缩进 N 个字符。(缺省为 0)。
                cino=                     cino=/4 
<code class="example">                  a = b;                    a = b;</code>
<code class="example">                  /* comment */                 /* comment */</code>
<code class="example">                  c = d;                    c = d;</code>

                                                        <b class="vimtag"> <a name="cino-(">cino-(</a> </b>
        (N    在没有结束的括号内，相对没有结束的括号所在行进行 N 个字符的缩
              进。对每一个额外没有结束的括号增加 <a href="options.html#'shiftwidth'">'shiftwidth'</a> 的缩进。如果 N
              为 0，或没有结束的括号是其所在行的首个非空白字符，和括号之后下一
              个非空白字符对齐。(缺省为 <a href="options.html#'shiftwidth'">'shiftwidth'</a> * 2)。

                cino=                     cino=(0 
<code class="example">                  if (c1 &amp;&amp; (c2 ||          if (c1 &amp;&amp; (c2 ||</code>
<code class="example">                              c3))                     c3))</code>
<code class="example">                      foo;                      foo;</code>
<code class="example">                  if (c1 &amp;&amp;                 if (c1 &amp;&amp;</code>
<code class="example">                          (c2 || c3))           (c2 || c3))</code>
<code class="example">                     {                         {</code>

                                                        <b class="vimtag"> <a name="cino-u">cino-u</a> </b>
        uN    和 (N 一样，但更深一级嵌套层。(缺省为 <a href="options.html#'shiftwidth'">'shiftwidth'</a>)。

                cino=                     cino=u2 
<code class="example">                  if (c123456789            if (c123456789</code>
<code class="example">                          &amp;&amp; (c22345                &amp;&amp; (c22345</code>
<code class="example">                              || c3))                 || c3))</code>

                                                        <b class="vimtag"> <a name="cino-U">cino-U</a> </b>
        UN    如果 N 非零，即使没结束的括号是所在行的首个非空白字符，也不忽略
              ( 或是 u 指定的缩进。(缺省为 0)。

                cino= 或 cino=(s          cino=(s,U1 
<code class="example">                  c = c1 &amp;&amp;                 c = c1 &amp;&amp;</code>
<code class="example">                      (                         (</code>
<code class="example">                       c2 ||                        c2 ||</code>
<code class="example">                       c3                           c3</code>
<code class="example">                      ) &amp;&amp; c4;                  ) &amp;&amp; c4;</code>

                                                        <b class="vimtag"> <a name="cino-w">cino-w</a> </b>
        wN    如果 N 非零，在没有结束的括号内如果使用 "(0" 或是 "u0"，或当没有
              结束的括号是所在行的首个非空白字符但使用 "U0" 时，对齐使用的是紧
              随在没有结束括号之后的字符，而不一定是其后首个非空白字符。
              (缺省为 0)。

                cino=(0                   cino=(0,w1 
<code class="example">                  if (   c1                 if (   c1</code>
<code class="example">                         &amp;&amp; (   c2              &amp;&amp; (   c2</code>
<code class="example">                                || c3))             || c3))</code>
<code class="example">                      foo;                      foo;</code>

                                                        <b class="vimtag"> <a name="cino-W">cino-W</a> </b>
        WN    如果 N 非零，在没有结束的括号内如果使用 "(0" 或是 "u0" 且当没有
              结束的括号是所在行的最后一个非空白字符且不是闭括号时，下一行相对
              外部代码块 (比如，行首或是下一层没结束的括号) 缩进 N 个字符。
              (缺省为 0)。

                cino=(0                    cino=(0,W4 
<code class="example">                  a_long_line(              a_long_line(</code>
<code class="example">                              argument,         argument,</code>
<code class="example">                              argument);        argument);</code>
<code class="example">                  a_short_line(argument,    a_short_line(argument,</code>
<code class="example">                               argument);                argument);</code>

                                                        <b class="vimtag"> <a name="cino-k">cino-k</a> </b>
        kN    在 "if"、"for" 或 "while" 之后没有结束的括号内且 N 非零时，覆盖
              "(N" 定义的行为: 相对外层上下文 (即 "if"、"for" 或 "while" 所在
              行) 缩进 N 个字符。对更深层的嵌套没有影响。影响 "wN" 等标志位的
              行为，但仅限于 "if"、"for" 和 "while" 条件。0 值对应的缺省是
              "(N" 标志位定义的行为。(缺省为 0)。

                cino=(0                    cino=(0,ks 
<code class="example">                  if (condition1            if (condition1</code>
<code class="example">                      &amp;&amp; condition2)                &amp;&amp; condition2)</code>
<code class="example">                      action();                 action();</code>
<code class="example">                  function(argument1        function(argument1</code>
<code class="example">                           &amp;&amp; argument2);            &amp;&amp; argument2);</code>

                                                        <b class="vimtag"> <a name="cino-m">cino-m</a> </b>
        mN    如果 N 非零，则将 ')' 开始的行和与其匹配的 '(' 所在行的第一个字
              符对齐。(缺省为 0)。

                cino=(s                   cino=(s,m1 
<code class="example">                  c = c1 &amp;&amp; (               c = c1 &amp;&amp; (</code>
<code class="example">                      c2 ||                     c2 ||</code>
<code class="example">                      c3                        c3</code>
<code class="example">                      ) &amp;&amp; c4;              ) &amp;&amp; c4;</code>
<code class="example">                  if (                      if (</code>
<code class="example">                      c1 &amp;&amp; c2                  c1 &amp;&amp; c2</code>
<code class="example">                     )                      )</code>
<code class="example">                      foo;                      foo;</code>

                                                        <b class="vimtag"> <a name="cino-M">cino-M</a> </b>
        MN    如果 N 非零，则将 ')' 开始的行与前一行的第一个字符对齐。
              (缺省为 0)。

                cino=                     cino=M1 
<code class="example">                  if (cond1 &amp;&amp;              if (cond1 &amp;&amp;</code>
<code class="example">                         cond2                     cond2</code>
<code class="example">                     )                             )</code>

                                <b class="vimtag"> <a name="java-cinoptions">java-cinoptions</a> </b> <b class="vimtag"> <a name="java-indenting">java-indenting</a> </b> <b class="vimtag"> <a name="cino-j">cino-j</a> </b>
        jN    正确地缩进 Java 匿名类，也适用于 Javascript。目前，'N' 的值并没
              有用到但其不能为 0 (比如 'j1')。'j1' 将对下面的代码段这样正确的
              缩进: 
<code class="example"></code>
<code class="example">                object.add(new ChangeListener() {</code>
<code class="example">                    public void stateChanged(ChangeEvent e) {</code>
<code class="example">                        do_something();</code>
<code class="example">                    }</code>
<code class="example">                });</code>

                        <b class="vimtag"> <a name="javascript-cinoptions">javascript-cinoptions</a> </b> <b class="vimtag"> <a name="javascript-indenting">javascript-indenting</a> </b> <b class="vimtag"> <a name="cino-J">cino-J</a> </b>
        JN    正确缩进 JavaScript 对象声明，不把它错误地当成标签。目前 'N' 的
              值并没有用到但不能为 0 (比如 'J1')。要打开之，也应考虑同时打开
               <a href="indent.html#cino-j">cino-j</a> 。 
<code class="example"></code>
<code class="example">                var bar = {</code>
<code class="example">                    foo: {</code>
<code class="example">                        that: this,</code>
<code class="example">                        some: ok,</code>
<code class="example">                    },</code>
<code class="example">                    "bar":{</code>
<code class="example">                        a : 2,</code>
<code class="example">                        b: "123abc",</code>
<code class="example">                        x: 4,</code>
<code class="example">                        "y": 5</code>
<code class="example">                    }</code>
<code class="example">                }</code>

                                                                <b class="vimtag"> <a name="cino-)">cino-)</a> </b>
        )N    Vim 最多在 N 行范围内查找没有结束的括号。这将缩小 Vim 用来查找
              括号的时间。(缺省 20 行)。

                                                                <b class="vimtag"> <a name="cino-star">cino-star</a> </b>
        *N    Vim 最多在 N 行范围内查找没有结束的注释。这将缩小 Vim 用来查找
              注释头部的时间。
              如果你的 /* * / 注释在 N 行后停止缩进，这里就是你要改的地方。
              (缺省 70 行)。

                                                                <b class="vimtag"> <a name="cino-%23">cino-#</a> </b>
        #N    如果 N 非零，识别 shell/Perl 风格 # 开头的注释，不识别预处理命令
              行；允许以 "#" 开头的行的右移。
              如果 N 为零 (缺省): 不识别 '#' 注释，但识别预处理命令行；不允许
              以 "#" 开头的行右移。

                                                                <b class="vimtag"> <a name="cino-P">cino-P</a> </b>
        PN    如果 N 非零，识别 C 编译指示 (pragma)，并像其它代码那样对其进行
              缩进；不影响其它预处理指令。
              如果 N 为零 (缺省): 不识别 C 编译指示，和其它预处理指令一样进行
              处理。


全部的缺省值是:
        cinoptions=&gt;s,e0,n0,f0,<code class="special">{0,}</code>0,^0,L-1,:s,=s,l0,b0,gs,hs,N0,E0,ps,ts,is,+s,
                        c3,C0,/0,(2s,us,U0,w0,W0,k0,m0,j0,J0,)20,*70,#0,P0

Vim 将一行从第一列开始，如果:
- 它以 '#' 开头 (预处理指令)，并且 <a href="options.html#'cinkeys'">'cinkeys'</a> 包含 '#0'。
- 它以一个标号 (后面跟随一个 ':' 的关键字，除了 "case" 或 "default" 以外) 开
  头，并且 <a href="options.html#'cinoptions'">'cinoptions'</a> 不包含使用正数值的 'L' 项目。
- 任何缩进的组合使这一行产生小于 0 的缩进。

</section><hr class="doubleline" /><section class=inner>
<h4>2. 按表达式缩进                                         <b class="vimtag"> <a name="indent-expression">indent-expression</a> </b></h4>
关于灵活缩进的一些基本知识在用户手册的  <a href="usr_30.html#30.3">30.3</a>  有解释。

如果你要写一个自己的缩进文件，它必须设定 <a href="options.html#'indentexpr'">'indentexpr'</a> 选项。设定 <a href="options.html#'indentkeys'">'indentkeys'</a>
也经常有用。
$VIMRUNTIME/indent/README.txt 文件有提示。
$VIMRUNTIME/indent 目录下有例子可以参考。


<code class="section">特 定 缩 进 文 件 的 若 干 评 注 </code>


CLOJURE                                 <b class="vimtag"> <a name="ft-clojure-indent">ft-clojure-indent</a> </b> <b class="vimtag"> <a name="clojure-indent">clojure-indent</a> </b>

Clojure 的缩进和传统的 Lisp 有所不同，部分由于方括号和尖括号的使用，还有部分是
社群习惯的差异。这些惯例又不是普遍遵循的。因为这样，Closure 缩进脚本提供了若干
可配置的选项。

(如果当前的 vim 不支持  <a href="builtin.html#searchpairpos()">searchpairpos()</a> ，缩进脚本回到普通 <a href="options.html#'lisp'">'lisp'</a> 缩进方式并忽
略以下所述的选项。)

                                                        <b class="vimtag"> <a name="g:clojure_maxlines">g:clojure_maxlines</a> </b>

设置  <a href="builtin.html#searchpairpos()">searchpairpos()</a>  的最大检索距离。较大的值牺牲性能以换取处理更长表达式
(form) 的正确性。0 会使检索没有限制。缺省值是 300。


                                                <b class="vimtag"> <a name="g:clojure_fuzzy_indent">g:clojure_fuzzy_indent</a> </b>
                                        <b class="vimtag"> <a name="g:clojure_fuzzy_indent_patterns">g:clojure_fuzzy_indent_patterns</a> </b>
                                        <b class="vimtag"> <a name="g:clojure_fuzzy_indent_blacklist">g:clojure_fuzzy_indent_blacklist</a> </b>

<a href="options.html#'lispwords'">'lispwords'</a> 选项是一个逗号分隔的单词列表，指定那些需要以两个空格缩进子表达式的
特殊表达式。

例如:

<code class="example">        (defn bad []</code>
<code class="example">              "错误的缩进")</code>
<code class="example"></code>
<code class="example">        (defn good []</code>
<code class="example">          "正确的缩进")</code>

如果想用  <a href="pattern.html#pattern">pattern</a>  来代替 <a href="options.html#'lispwords'">'lispwords'</a>，可用模糊缩进功能:

<code class="example">        " 缩进</code>
<code class="example">        let g:clojure_fuzzy_indent = 1</code>
<code class="example">        let g:clojure_fuzzy_indent_patterns = ['^with', '^def', '^let']</code>
<code class="example">        let g:clojure_fuzzy_indent_blacklist =</code>
<code class="example">                \ ['-fn$', '\v^with-%(meta|out-str|loading-context)$']</code>
<code class="example"></code>
 <a href="indent.html#g:clojure_fuzzy_indent_patterns">g:clojure_fuzzy_indent_patterns</a>  和  <a href="indent.html#g:clojure_fuzzy_indent_blacklist">g:clojure_fuzzy_indent_blacklist</a>  是模式
的列表，用于匹配 Lisp 列表 (list) 的头部去掉限定词部分的符号。这
意味着形如 "^foo" 的模式会匹配以下的候选: "foobar"、"my.ns/foobar" 和
"#'foobar"。

每个候选词会以下列顺序进行是否需要特殊处理的测试:

        1. 若单词按本义出现在 <a href="options.html#'lispwords'">'lispwords'</a> 中，返回真
        2. 若单词匹配  <a href="indent.html#g:clojure_fuzzy_indent_blacklist">g:clojure_fuzzy_indent_blacklist</a>  中的某个模式，返回假
        3. 若单词匹配  <a href="indent.html#g:clojure_fuzzy_indent_patterns">g:clojure_fuzzy_indent_patterns</a>  中的某个模式，返回真
        4. 否则返回假，按正常方式缩进

                                        <b class="vimtag"> <a name="g:clojure_special_indent_words">g:clojure_special_indent_words</a> </b>

有些 Closure 的表达式的缩进方式要求每个子表达式只缩进两格，不管 <a href="options.html#'lispwords'">'lispwords'</a>
如何设置。如果你有要求这种独特的缩进方式的结构，可以把相应的符号加入下面的缺省
列表。

<code class="example">        " 缺省</code>
<code class="example">        let g:clojure_special_indent_words =</code>
<code class="example">           \ 'deftype,defrecord,reify,proxy,extend-type,extend-protocol,letfn'</code>

                                        <b class="vimtag"> <a name="g:clojure_align_multiline_strings">g:clojure_align_multiline_strings</a> </b>

多行字符串的后续行和引导引号之后的列对齐，而不是对齐与同一列。

示例:

<code class="example">        (def default</code>
<code class="example">          "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do</code>
<code class="example">          eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut</code>
<code class="example">          enim ad minim veniam, quis nostrud exercitation ullamco laboris</code>
<code class="example">          nisi ut aliquip ex ea commodo consequat.")</code>
<code class="example"></code>
<code class="example">        (def aligned</code>
<code class="example">          "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do</code>
<code class="example">           eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut</code>
<code class="example">           enim ad minim veniam, quis nostrud exercitation ullamco laboris</code>
<code class="example">           nisi ut aliquip ex ea commodo consequat.")</code>


                                                <b class="vimtag"> <a name="g:clojure_align_subforms">g:clojure_align_subforms</a> </b>

缺省括号内的复合表达式以函数调用形式出现，头部子表达式在单独一行上，后续的子表
达式则相对开括号缩进 2 个空格:

<code class="example">        (foo</code>
<code class="example">          bar</code>
<code class="example">          baz)</code>

设置此选项为 '1' 改变此行为，使得所有的子表达式在同一列对齐，这模拟了
clojure-mode.el 的缺省行为:

<code class="example">        (foo</code>
<code class="example">         bar</code>
<code class="example">         baz)</code>


FORTRAN                                                 <b class="vimtag"> <a name="ft-fortran-indent">ft-fortran-indent</a> </b>

Block if、select case、where 和 forall 代码块被缩进。type、interface、
associate、block 和 enum 结构也是。subrountine、function、module 和 program
block 的缩进可选。如果 Fortran 在自由格式下，注释，标号语句和续行被缩进；如果
在固定宽度格式下，这些就不会被缩进，因为左边必须要求留出空白。因此，在固定宽度
格式下，需要手动对标号语句和续行缩进。关于检测源码格式的更深入讨论，参见
 <a href="syntax.html#ft-fortran-syntax">ft-fortran-syntax</a> 。

<code class="section">do 循环 </code>
缺省情况下，所有的 do 循环保持原样，不缩进。在 Fortran 里，循环甚至是多重循环
可以结束于一个任意类型的带标号可执行语句，使得 do 循环非结构化。对其正确的缩进
需要编译器级别的语法分析。对于这样 do 循环结束于任意类型的带标号语句的老式代码
可以使用 Tidy (<a href="http://www.unb.ca/chem/ajit/f_tidy.htm">http://www.unb.ca/chem/ajit/f_tidy.htm</a>) 等专门的程序缩进。结构
化的 do/continue 循环也保持不缩进，因为 continue 除了结束 do 循环以外还有其它
的用途。Tidy 可以将结构化的 do/continue 循环转换成 do/enddo 的形式。do/enddo
类型的循环能被缩进。如果你只使用结构化的 do/enddo 形式的循环，可以在 .vimrc 中
作如下声明: 
<code class="example"></code>
<code class="example">   let fortran_do_enddo=1</code>
<code class="example"></code>
这样 do 循环就被缩进了。如果只是在比如 .f90 文件里，你的所有循环都是 do/enddo
形式，那么可以像下面一样用自动命令设置一个缓冲区标志位 
<code class="example"></code>
<code class="example">  au! BufRead,BufNewFile *.f90 let b:fortran_do_enddo=1</code>
<code class="example"></code>
使 .f90 文件里的 do 循环被缩进而在其它扩展名里，比如 .for 文件中不被缩进。

<code class="section">程序单元 </code>
缺省打开程序单元 (subrountine、function、module 和 program block) 的缩进，如果
需要轻量级的节省屏幕宽度的缩进风格，可以关闭之。要关闭所有 fortran 文件的程序
单元的缩进，在 .vimrc 里设置全局变量 fortran_indent_less 
<code class="example"></code>
<code class="example">  let fortran_indent_less=1</code>
<code class="example"></code>
要更精细的控制，可以设置对应的缓冲区局部变量 
<code class="example"></code>
<code class="example">  let b:fortran_indent_less=1</code>
<code class="example"></code>
<code class="example"></code>
HTML                            <b class="vimtag"> <a name="ft-html-indent">ft-html-indent</a> </b> <b class="vimtag"> <a name="html-indent">html-indent</a> </b> <b class="vimtag"> <a name="html-indenting">html-indenting</a> </b>

这里说明定制 HTML 缩进的相关变量，可以把它们放到你的 vimrc 里。

可以设置 <code class="special">&lt;script&gt;</code> 和 <code class="special">&lt;style&gt;</code> 这些 "区块标签" 之后的首行缩进 (缺省为 "zero"): 
<code class="example"></code>
<code class="example">      :let g:html_indent_script1 = "inc"</code>
<code class="example">      :let g:html_indent_style1 = "inc"</code>

<code class="section">      值        含义 </code>
      "zero"    零缩进
      "auto"    自动缩进 (和匹块标签相同的缩进)
      "inc"     自动缩进 + 一个缩进位置

可以设置起始 &lt;tag 行之后 HTML 属性的缩进: 
<code class="example"></code>
<code class="example">      :let g:html_indent_attribute = 1</code>

<code class="section">      值        含义 </code>
      1         自动缩进，比 &lt;tag 多一层缩进
      2         自动缩进，多两层缩进 (缺省)
      &gt; 2       自动缩进，更多层的缩进

缺省，给许多标签之后的内容增加缩进 (见脚本里的 "Add Indent Tags")。可以加入更
多类似的标签: 
<code class="example"></code>
<code class="example">      :let g:html_indent_inctags = "html,body,head,tbody"</code>
<code class="example"></code>
还可以删除已有的标签: 
<code class="example"></code>
<code class="example">      :let g:html_indent_autotags = "th,td,tr,tfoot,thead"</code>
<code class="example"></code>
这两个变量的缺省值为空。<code class="note">注意</code>: 初始的 "inctags" 值只在每个 Vim 会话中定义一次。

只在脚本执行时读入这些用户变量。要在会话中间执行更改，除了重载 HTML 文件外，可
以手动调用: 
<code class="example"></code>
<code class="example">      :call HtmlIndent_CheckUserSettings()</code>
<code class="example"></code>
细节:
  "区块标签" 内的缩进的计算，有些 "外来的" 内容:
<code class="section">      区域标签   缩进表达式         适用情况 </code>
      <code class="special">&lt;script&gt;</code> : <code class="special">{可定制}</code>           如果是区块的首行
               : cindent(v:lnum)    如果没有属性或其中包含 "java"
               : -1                 否则 (vbscript、tcl、...)
      <code class="special">&lt;style&gt;</code>  : <code class="special">{可定制}</code>           如果是区块的首行
               : GetCSSIndent()     否则
      &lt;!-- --&gt; : -1


MATLAB                  <b class="vimtag"> <a name="ft-matlab-indent">ft-matlab-indent</a> </b> <b class="vimtag"> <a name="matlab-indent">matlab-indent</a> </b> <b class="vimtag"> <a name="matlab-indenting">matlab-indenting</a> </b>

MATLAB 编辑器/调试器语言首选项中的设置函数缩进格式相当于: 
<code class="example">    :let g:MATLAB_function_indent = {0、1 或 2 (缺省)}</code>
<code class="example"></code>
其中 0 用于经典模式，1 用于缩进嵌套函数 而 2 用于缩进全部函数。


PHP                             <b class="vimtag"> <a name="ft-php-indent">ft-php-indent</a> </b> <b class="vimtag"> <a name="php-indent">php-indent</a> </b> <b class="vimtag"> <a name="php-indenting">php-indenting</a> </b>

<code class="note">注意</code>:   只有激活 PHP 语法  <a href="syntax.html#syntax">syntax</a>  才能正确缩进 PHP 文件。

如果在 Unix <a href="options.html#'fileformat'">'fileformat'</a> 下编辑文件而换行符之前有 '\r' 字符，缩进的处理会不正
确。需要先去除这些没有的字符。例如可用: 
<code class="example"></code>
<code class="example">    :%s /\r$//g</code>
<code class="example"></code>
或者，你可以简单地  <a href="eval.html#:let">:let</a>  变量 PHP_removeCRwhenUnix 为 1，脚本会在 Vim 载入
PHP 文件 (每次  <a href="autocmd.html#BufRead">BufRead</a> ) 时安静地删除它们。

<code class="section">选项: </code>

PHP 缩进可以通过修改若干全局变量的值来对几个方面进行改变:

                                        <b class="vimtag"> <a name="php-comment">php-comment</a> </b> <b class="vimtag"> <a name="PHP_autoformatcomment">PHP_autoformatcomment</a> </b>
要缺省不打开注释的自动排版 (如果要使用自己的 <a href="options.html#'formatoptions'">'formatoptions'</a> 的话): 
<code class="example">    :let g:PHP_autoformatcomment = 0</code>
<code class="example"></code>
否则，'t' 会从 <a href="options.html#'formatoptions'">'formatoptions'</a> 字符串中去除，并加上 "qrowcb"，详见
 <a href="change.html#fo-table">fo-table</a> 。
</section><hr class="singleline" /><section class=inner>

                                                        <b class="vimtag"> <a name="PHP_outdentSLComments">PHP_outdentSLComments</a> </b>
要给单行注释增加额外的缩进: 
<code class="example">    :let g:PHP_outdentSLComments = N</code>
<code class="example"></code>
其中的 N 是要增加的 <a href="options.html#'shiftwidth'">'shiftwidth'</a> 的倍数。

只影响如下所示的单行注释: 
<code class="example">    # Comment</code>
<code class="example">    // Comment</code>
<code class="example">    /* Comment */</code>
</section><hr class="singleline" /><section class=inner>

                                                        <b class="vimtag"> <a name="PHP_default_indenting">PHP_default_indenting</a> </b>
要给所有 PHP 行增加额外的缩进 N 个 <a href="options.html#'shiftwidth'">'shiftwidth'</a>: 
<code class="example">    :let g:PHP_default_indenting = N</code>
<code class="example"></code>
例如，如果 N = 1:

<code class="example">    &lt;?php</code>
<code class="example">        if (!isset($History_lst_sel))</code>
<code class="example">            if (!isset($History_lst_sel))</code>
<code class="example">                if (!isset($History_lst_sel)) {</code>
<code class="example">                    $History_lst_sel=0;</code>
<code class="example">                } else</code>
<code class="example">                    $foo="bar";</code>
<code class="example"></code>
<code class="example">        $command_hist = TRUE;</code>
<code class="example">    ?&gt;</code>
(<code class="note">注意</code> PHP 标识符和它包含的代码之间额外的缩进)
</section><hr class="singleline" /><section class=inner>

                                                        <b class="vimtag"> <a name="PHP_outdentphpescape">PHP_outdentphpescape</a> </b>
要使 PHP 标签和和包围它的非 PHP 代码使用相同的缩进 (只影响 PHP 转义标签): 
<code class="example">    :let g:PHP_outdentphpescape = 0</code>
</section><hr class="singleline" /><section class=inner>

                                                        <b class="vimtag"> <a name="PHP_removeCRwhenUnix">PHP_removeCRwhenUnix</a> </b>
要在 <a href="options.html#'fileformat'">'fileformat'</a> 设为 Unix 时自动删除 '\r' 字符: 
<code class="example">    :let g:PHP_removeCRwhenUnix = 1</code>
</section><hr class="singleline" /><section class=inner>

                                                        <b class="vimtag"> <a name="PHP_BracesAtCodeLevel">PHP_BracesAtCodeLevel</a> </b>
要使花括号的缩进和其包含的代码相同: 
<code class="example">    :let g:PHP_BracesAtCodeLevel = 1</code>
<code class="example"></code>
给出的结果会变成: 
<code class="example">    if ($foo)</code>
<code class="example">        {</code>
<code class="example">        foo();</code>
<code class="example">        }</code>
而不是: 
<code class="example">    if ($foo)</code>
<code class="example">    {</code>
<code class="example">        foo();</code>
<code class="example">    }</code>
<code class="example"></code>
<code class="note">注意</code>:   如果使用此选项，缩进可能会稍慢一些，因为无法使用若干优化。
</section><hr class="singleline" /><section class=inner>

                                        <b class="vimtag"> <a name="PHP_vintage_case_default_indent">PHP_vintage_case_default_indent</a> </b>
要缩进 switch() 块的 'case:' 和 'default:' 语句: 
<code class="example">    :let g:PHP_vintage_case_default_indent = 1</code>
<code class="example"></code>
PHP 中 'case/default' 块并非必须使用花括号，因此，'case:' 和 'default:' 和
'switch()' 的缩进层次相同，以避免不必要的缩进。可用上述的选项来恢复传统的缩进
方式。
</section><hr class="singleline" /><section class=inner>

                                                        <b class="vimtag"> <a name="PHP_noArrowMatching">PHP_noArrowMatching</a> </b>
缺省缩进脚本会缩进多行的链式调用，使 '-&gt;' 位置匹配: 
<code class="example"></code>
<code class="example">    $user_name_very_long-&gt;name()</code>
<code class="example">                        -&gt;age()</code>
<code class="example">                        -&gt;info();</code>
<code class="example"></code>
把此选项设为 1 可以回到经典缩进方式: 
<code class="example">    :let g:PHP_noArrowMatching = 1</code>
<code class="example"></code>
会得到以下结果: 
<code class="example"></code>
<code class="example">    $user_name_very_long-&gt;name()</code>
<code class="example">        -&gt;age()</code>
<code class="example">        -&gt;info();</code>
<code class="example"></code>
<code class="example"></code>
</section><hr class="singleline" /><section class=inner>

                                        <b class="vimtag"> <a name="PHP_IndentFunctionCallParameters">PHP_IndentFunctionCallParameters</a> </b>
为多行函数调用的参数额外缩进。 
<code class="example">    let g:PHP_IndentFunctionCallParameters = 1</code>
<code class="example"></code>
函数调用参数会额外多缩进一层。如果是两个空格的缩进: 
<code class="example"></code>
<code class="example">    function call_the_thing(</code>
<code class="example">      $with_this,</code>
<code class="example">      $and_that</code>
<code class="example">    ) {</code>
<code class="example">      $this-&gt;do_the_thing(</code>
<code class="example">          $with_this,</code>
<code class="example">          $and_that</code>
<code class="example">      );</code>
<code class="example">    }</code>
<code class="example"></code>
</section><hr class="singleline" /><section class=inner>

                                <b class="vimtag"> <a name="PHP_IndentFunctionDeclarationParameters">PHP_IndentFunctionDeclarationParameters</a> </b>
为多行函数定义的参数额外缩进。 
<code class="example">    let g:PHP_IndentFunctionDeclarationParameters = 1</code>
<code class="example"></code>
函数声明参数会额外多缩进一层。如果是两个空格的缩进: 
<code class="example"></code>
<code class="example">    function call_the_thing(</code>
<code class="example">        $with_this,</code>
<code class="example">        $and_that</code>
<code class="example">    ) {</code>
<code class="example">      $this-&gt;do_the_thing(</code>
<code class="example">        $with_this,</code>
<code class="example">        $and_that</code>
<code class="example">      );</code>
<code class="example">    }</code>
<code class="example"></code>
PYTHON                                                  <b class="vimtag"> <a name="ft-python-indent">ft-python-indent</a> </b>

可用  <code class="badlink">g:python_indent</code>   <a href="eval.html#Dictionary">Dictionary</a>  设置缩进值，为此需要在加入项目之前先创建此
字典: 
<code class="example">        let g:python_indent = {}</code>
下面所举的例子给出其缺省值。<code class="note">注意</code> 字典变量用表达式赋值，所以你以后可以改变
<a href="options.html#'shiftwidth'">'shiftwidth'</a> 的值而不无需更新这些值。

在 "(" 后的缩进: 
<code class="example">        let g:python_indent.open_paren = 'shiftwidth() * 2'</code>
在嵌套的括号后的缩进: 
<code class="example">        let g:python_indent.nested_paren = 'shiftwidth()'</code>
续行的缩进: 
<code class="example">        let g:python_indent.continue = 'shiftwidth() * 2'</code>
<code class="example"></code>
缺省，多行结构上的结束括号和前一行首个非空白字符对齐。
如果想要和开启多行结构的行的首字符对齐，复位此键: 
<code class="example">        let g:python_indent.closed_paren_align_last_line = v:false</code>
<code class="example"></code>
此方法使用  <a href="builtin.html#searchpair()">searchpair()</a>  往回找未闭合的括号。这有时会较慢，因此有 150 毫秒的
超时。如果你<code class="note">注意</code>到缩进不正确，可以设置长一些的超时，以毫秒计: 
<code class="example">        let g:python_indent.searchpair_timeout = 500</code>
<code class="example"></code>
如果往回找未闭合的括号还是太慢，特别是在复制粘贴操作的时候，或者你不需要在多行
括号内进行缩进，可以完全关闭此功能: 
<code class="example">        let g:python_indent.disable_parentheses_indenting = 1</code>
<code class="example"></code>
为后向兼容，也支持以下变量: 
<code class="example">        g:pyindent_open_paren</code>
<code class="example">        g:pyindent_nested_paren</code>
<code class="example">        g:pyindent_continue</code>
<code class="example">        g:pyindent_searchpair_timeout</code>
<code class="example">        g:pyindent_disable_parentheses_indenting</code>
<code class="example"></code>
R                                                               <b class="vimtag"> <a name="ft-r-indent">ft-r-indent</a> </b>

函数参数如果跨越多行，会进行对齐。如果不想函数参数进行对齐，在  <a href="starting.html#vimrc">vimrc</a>  里放入:

<code class="example">   let r_indent_align_args = 0</code>

所有注释字符 # 开始的行和正常 R 代码采用相同的缩进级别。Emacs/ESS 的用户可能习
惯单个 # 的缩进于第 40 列，而 ## 以正常 R 代码方式缩进，### 不缩进。 如果你习
惯 Emacs/ESS 的注释对齐方式，在  <a href="starting.html#vimrc">vimrc</a>  里放入:

<code class="example">   let r_indent_ess_comments = 1</code>

要单个 # 开始行的对齐不在第 40 列，给 r_indent_common_column 设置一个新值，如
下例所示:

<code class="example">   let r_indent_comment_column = 30</code>

缩进所有以 "&lt;-" 结束的行之后的代码。Emacs/ESS 则不缩进顶层函数的代码。如果你希
望 Vim-R-plugin 这方面采用 Emacs/ESS 风格，在  <a href="starting.html#.vimrc">.vimrc</a>  里放入:

<code class="example">   let r_indent_ess_compatible = 1</code>

下面举一个打开和关闭此选项的缩进例子:

<code class="example">   ### r_indent_ess_compatible = 1           ### r_indent_ess_compatible = 0</code>
<code class="example">   foo &lt;-                                    foo &lt;-</code>
<code class="example">       function(x)                               function(x)</code>
<code class="example">   {                                             {</code>
<code class="example">       paste(x)                                      paste(x)</code>
<code class="example">   }                                             }</code>

此代码会在匹配模式 `'\(&amp;\| <code class="badlink">\</code> +\ <code class="badlink">-\</code> \*\ <a href="pattern.html#%2F\">/\</a> =\ <code class="badlink">\~\</code> %\|-&gt;\)\s*$'` 的行后缩进。如
果你希望在匹配其它模式的行后缩进，可以在  <a href="starting.html#vimrc">vimrc</a>  中设置  <code class="badlink">r_indent_op_pattern</code> 
合适的值。


SHELL                                                   <b class="vimtag"> <a name="ft-sh-indent">ft-sh-indent</a> </b>

通过 b:sh_indent_defaults 字典  <a href="eval.html#Dictionary">Dictionary</a>  的以下键，可以配置外壳文件在各种情
况下使用的缩进距离。它们可以是某个特定的值或者是返回所需距离的函数引用
 <a href="eval.html#Funcref">Funcref</a> :

b:sh_indent_options[<code class="badlink">'default'</code>]  缺省缩进距离。

b:sh_indent_options['continuation-line']
                                加到续行上的缩进距离。

b:sh_indent_options['case-labels']
                                加到 case 标签上的缩进距离。
                                (没有实际实现)

b:sh_indent_options['case-statements']
                                加到 case 语句上的缩进距离。

b:sh_indent_options['case-breaks']
                                加到 (更有可能，减少) case break 语句上的缩进
                                距离。

VERILOG                                                 <b class="vimtag"> <a name="ft-verilog-indent">ft-verilog-indent</a> </b>

一般的代码块，像 if、for、case、always、initial、function、specify、begin 等等
都被缩进。module 代码块 (处于第一级) 缺省不被缩进。你可以在 .vimrc 里打开这个
缩进: 
<code class="example"></code>
<code class="example">  let b:verilog_indent_modules = 1</code>
<code class="example"></code>
这样 module 代码块就被缩进。要关闭缩进，删除这个变量: 
<code class="example"></code>
<code class="example">  :unlet b:verilog_indent_modules</code>
<code class="example"></code>
要只对 Verilog 文件设定变量，可以这样做: 
<code class="example"></code>
<code class="example">  au BufReadPost * if exists("b:current_syntax")</code>
<code class="example">  au BufReadPost *   if b:current_syntax == "verilog"</code>
<code class="example">  au BufReadPost *     let b:verilog_indent_modules = 1</code>
<code class="example">  au BufReadPost *   endif</code>
<code class="example">  au BufReadPost * endif</code>
<code class="example"></code>
另外，可以设定 b:verilog_indent_width 来改变缩进值 (缺省为 <a href="options.html#'shiftwidth'">'shiftwidth'</a>): 
<code class="example">  let b:verilog_indent_width = 4</code>
<code class="example">  let b:verilog_indent_width = shiftwidth() * 2</code>
<code class="example"></code>
你还可以打开详细模式来帮助调试: 
<code class="example"></code>
<code class="example">  let b:verilog_indent_verbose = 1</code>
<code class="example"></code>
不要忘了要先设定 ":set cmdheight=2" 才能显示信息。


VHDL                                                    <b class="vimtag"> <a name="ft-vhdl-indent">ft-vhdl-indent</a> </b>

缺省执行 类属 (generic) /端口 (port) 映射语句的对齐。下例说明这种对齐的应用: 
<code class="example"></code>
<code class="example">  ENTITY sync IS</code>
<code class="example">  PORT (</code>
<code class="example">         clk        : IN  STD_LOGIC;</code>
<code class="example">         reset_n    : IN  STD_LOGIC;</code>
<code class="example">         data_input : IN  STD_LOGIC;</code>
<code class="example">         data_out   : OUT STD_LOGIC</code>
<code class="example">       );</code>
<code class="example">  END ENTITY sync;</code>
<code class="example"></code>
要关闭之，在 .vimrc 文件中加上 
<code class="example"></code>
<code class="example">  let g:vhdl_indent_genportmap = 0</code>
<code class="example"></code>
而上例也随之改变了对齐: 
<code class="example"></code>
<code class="example">  ENTITY sync IS</code>
<code class="example">  PORT (</code>
<code class="example">    clk        : IN  STD_LOGIC;</code>
<code class="example">    reset_n    : IN  STD_LOGIC;</code>
<code class="example">    data_input : IN  STD_LOGIC;</code>
<code class="example">    data_out   : OUT STD_LOGIC</code>
<code class="example">  );</code>
<code class="example">  END ENTITY sync;</code>
<code class="example"></code>
</section><hr class="singleline" /><section class=inner>

缺省执行右手边赋值 "&lt;=" 语句的对齐。下例说明这种对齐的应用: 
<code class="example"></code>
<code class="example">  sig_out &lt;= (bus_a(1) AND</code>
<code class="example">             (sig_b OR sig_c)) OR</code>
<code class="example">             (bus_a(0) AND sig_d);</code>
<code class="example"></code>
要关闭之，在 .vimrc 文件中加上 
<code class="example"></code>
<code class="example">  let g:vhdl_indent_rhsassign = 0</code>
<code class="example"></code>
而上例也随之改变了对齐: 
<code class="example"></code>
<code class="example">  sig_out &lt;= (bus_a(1) AND</code>
<code class="example">    (sig_b OR sig_c)) OR</code>
<code class="example">    (bus_a(0) AND sig_d);</code>
<code class="example"></code>
</section><hr class="singleline" /><section class=inner>

整行注释 ("--" 打头的行) 的缩进和上一行注释对齐， <code class="emphasis">如果</code>  "--" 之后有一个空格的
话。

示例: 
<code class="example"></code>
<code class="example">  sig_a &lt;= sig_b; -- 开始注释</code>
<code class="example">                  -- 注释继续</code>
<code class="example">                  -- 同一注释的更多内容</code>
<code class="example"></code>
在插入模式下，输入 "-- " 后 (<code class="note">注意</code>空格 " ")，按 <code class="keystroke">CTRL-F</code> 会使当前的 "-- " 和上一
行的 "--" 对齐。

如果紧邻的上一行不包含 "--"， <code class="emphasis">那么</code> 整行注释会和下一个非空白且 <code class="emphasis">不是</code> 整行注释的
行的起始位置对齐。

下列代码的缩进: 
<code class="example"></code>
<code class="example">  sig_c &lt;= sig_d; -- 注释 0</code>
<code class="example">         -- 注释 1</code>
<code class="example">               -- 注释 2</code>
<code class="example">    --debug_code:</code>
<code class="example">    --PROCESS(debug_in)</code>
<code class="example">         --BEGIN</code>
<code class="example">            --  FOR i IN 15 DOWNTO 0 LOOP</code>
<code class="example">             --    debug_out(8*i+7 DOWNTO 8*i) &lt;= debug_in(15-i);</code>
<code class="example">            --  END LOOP;</code>
<code class="example">     --END PROCESS debug_code;</code>
<code class="example"></code>
<code class="example">      -- 注释 3</code>
<code class="example">  sig_e &lt;= sig_f; -- 注释 4</code>
<code class="example">           -- 注释 5</code>
<code class="example"></code>
结果是: 
<code class="example"></code>
<code class="example">  sig_c &lt;= sig_d; -- 注释 0</code>
<code class="example">                  -- 注释 1</code>
<code class="example">                  -- 注释 2</code>
<code class="example">  --debug_code:</code>
<code class="example">  --PROCESS(debug_in)</code>
<code class="example">  --BEGIN</code>
<code class="example">  --  FOR i IN 15 DOWNTO 0 LOOP</code>
<code class="example">  --    debug_out(8*i+7 DOWNTO 8*i) &lt;= debug_in(15-i);</code>
<code class="example">  --  END LOOP;</code>
<code class="example">  --END PROCESS debug_code;</code>
<code class="example"></code>
<code class="example">  -- 注释 3</code>
<code class="example">  sig_e &lt;= sig_f; -- 注释 4</code>
<code class="example">                  -- 注释 5</code>
<code class="example"></code>
<code class="note">注意</code>到 "--debug_code:" 不和 "-- comment 2" 对齐，因为 "--debug_code:" 的 "--"
之后没有空白。

基于注释缩进的动态性，缩进应该执行 <code class="emphasis">两次</code> 。第一遍缩进代码，第二遍依据已正确缩进
的代码来缩进整行注释。


VIM                                                     <b class="vimtag"> <a name="ft-vim-indent">ft-vim-indent</a> </b>
                                                        <b class="vimtag"> <a name="g:vim_indent">g:vim_indent</a> </b>
 <a href="indent.html#g:vim_indent">g:vim_indent</a>  字典变量可用于设置 Vim 脚本的缩进。支持 3 个键值，
 <code class="badlink">line_continuation</code> 、 <code class="badlink">more_in_bracket_block</code>  和  <code class="badlink">searchpair_timeout</code> 。
 <code class="badlink">line_continuation</code>  期待数值，指定以反斜杠开始的续行的额外缩进层次，缺省为
`shiftwidth() * 3`。也接受字符串，会在运行时计算。
 <code class="badlink">more_in_bracket_block</code>  期待布尔型值；打开时，括号包围的块的内部会加入一个额外
的  <a href="builtin.html#shiftwidth()">shiftwidth()</a> 。缺省为  <a href="eval.html#v:false">v:false</a> 。
 <code class="badlink">searchpair_timeout</code>  期待数值，会传递给  <a href="builtin.html#searchpair()">searchpair()</a>  作为超时。增加此值会给
出更准确的结果，但缩进会花费更长时间。缺省为 100 (毫秒)。

配置示例:

        let g:vim_indent = #{
            \ line_continuation: shiftwidth() * 3,
            \ more_in_bracket_block: v:false,
            \ searchpair_timeout: 100,
            \ }

                                                        <b class="vimtag"> <a name="g:vim_indent_cont">g:vim_indent_cont</a> </b>
此变量等价于  <code class="badlink">g:vim_indent.line_continuation</code> 。为后向兼容而保留。


 vim:tw=78:ts=8:noet:ft=help:norl:
</section>
</article>
<footer>
Generated by vim2html
</footer>
</body>
</html>
